/**
 * 权限辅助工具 - 简化权限检查逻辑
 */

import React from 'react';

// 权限继承关系配置
const PERMISSION_HIERARCHY: Record<string, string[]> = {
  // 用户管理权限继承
  'user.manage': ['user.view', 'user.create', 'user.update', 'user.delete', 'user.export'],
  
  // 角色管理权限继承
  'role.manage': ['role.view', 'role.create', 'role.update', 'role.delete'],
  
  // 路由管理权限继承
  'route.manage': ['route.view', 'route.create', 'route.update', 'route.delete'],
  
  // 权限管理权限继承
  'permission.manage': ['permission.view', 'permission.create', 'permission.update', 'permission.delete'],
  
  // 血缘管理权限继承
  'lineage.manage': ['lineage.view', 'lineage.analyze'],
  
  // 系统管理权限继承
  'system.admin': ['user.manage', 'role.manage', 'permission.manage', 'route.manage', 'lineage.manage'],
};

// 权限组配置
const PERMISSION_GROUPS: Record<string, string[]> = {
  // 基础查看权限组
  'basic.view': ['user.view', 'role.view', 'lineage.view'],
  
  // 管理员权限组
  'admin.full': ['system.admin'],
  
  // 数据分析师权限组
  'analyst': ['lineage.view', 'lineage.analyze'],
  
  // 用户管理员权限组
  'user.admin': ['user.manage', 'role.view'],
};

/**
 * 权限辅助类
 */
class PermissionHelper {
  /**
   * 展开权限继承关系
   * @param permissions 用户权限列表
   * @returns 展开后的权限列表
   */
  static expandPermissions(permissions: string[]): string[] {
    const expandedPermissions = new Set<string>();
    
    // 添加原始权限
    permissions.forEach(permission => {
      expandedPermissions.add(permission);
      
      // 添加继承的权限
      const inheritedPermissions = PERMISSION_HIERARCHY[permission];
      if (inheritedPermissions) {
        inheritedPermissions.forEach(inherited => {
          expandedPermissions.add(inherited);
        });
      }
    });
    
    return Array.from(expandedPermissions);
  }

  /**
   * 检查用户是否具有指定权限
   * @param userPermissions 用户权限列表
   * @param requiredPermission 需要的权限
   * @returns 是否具有权限
   */
  static hasPermission(userPermissions: string[], requiredPermission: string): boolean {
    const expandedPermissions = this.expandPermissions(userPermissions);
    return expandedPermissions.includes(requiredPermission);
  }

  /**
   * 检查用户是否具有任一权限
   * @param userPermissions 用户权限列表
   * @param requiredPermissions 需要的权限列表（满足任一即可）
   * @returns 是否具有权限
   */
  static hasAnyPermission(userPermissions: string[], requiredPermissions: string[]): boolean {
    const expandedPermissions = this.expandPermissions(userPermissions);
    return requiredPermissions.some(permission => expandedPermissions.includes(permission));
  }

  /**
   * 检查用户是否具有所有权限
   * @param userPermissions 用户权限列表
   * @param requiredPermissions 需要的权限列表（必须全部满足）
   * @returns 是否具有权限
   */
  static hasAllPermissions(userPermissions: string[], requiredPermissions: string[]): boolean {
    const expandedPermissions = this.expandPermissions(userPermissions);
    return requiredPermissions.every(permission => expandedPermissions.includes(permission));
  }

  /**
   * 获取权限组包含的所有权限
   * @param groupName 权限组名称
   * @returns 权限列表
   */
  static getPermissionGroup(groupName: string): string[] {
    const groupPermissions = PERMISSION_GROUPS[groupName];
    if (!groupPermissions) {
      return [];
    }
    
    return this.expandPermissions(groupPermissions);
  }

  /**
   * 检查用户是否属于指定权限组
   * @param userPermissions 用户权限列表
   * @param groupName 权限组名称
   * @returns 是否属于权限组
   */
  static hasPermissionGroup(userPermissions: string[], groupName: string): boolean {
    const groupPermissions = this.getPermissionGroup(groupName);
    return this.hasAllPermissions(userPermissions, groupPermissions);
  }

  /**
   * 获取权限的显示名称
   * @param permission 权限标识
   * @returns 显示名称
   */
  static getPermissionDisplayName(permission: string): string {
    const displayNames: Record<string, string> = {
      // 用户权限
      'user.view': '查看用户',
      'user.create': '创建用户',
      'user.update': '更新用户',
      'user.delete': '删除用户',
      'user.manage': '管理用户',
      'user.export': '导出用户',
      
      // 角色权限
      'role.view': '查看角色',
      'role.create': '创建角色',
      'role.update': '更新角色',
      'role.delete': '删除角色',
      'role.manage': '管理角色',
      
      // 权限管理
      'permission.view': '查看权限',
      'permission.create': '创建权限',
      'permission.update': '更新权限',
      'permission.delete': '删除权限',
      'permission.manage': '管理权限',
      
      // 路由管理
      'route.view': '查看路由',
      'route.create': '创建路由',
      'route.update': '更新路由',
      'route.delete': '删除路由',
      'route.manage': '管理路由',
      
      // 数据血缘
      'lineage.view': '查看血缘',
      'lineage.analyze': '分析血缘',
      'lineage.manage': '管理血缘',
      
      // 系统管理
      'system.admin': '系统管理员',
    };
    
    return displayNames[permission] || permission;
  }

  /**
   * 获取权限的分类
   * @param permission 权限标识
   * @returns 权限分类
   */
  static getPermissionCategory(permission: string): string {
    const [category] = permission.split('.');
    const categoryNames: Record<string, string> = {
      'user': '用户管理',
      'role': '角色管理',
      'permission': '权限管理',
      'route': '路由管理',
      'lineage': '数据血缘',
      'system': '系统管理',
    };
    
    return categoryNames[category] || '其他';
  }

  /**
   * 按分类分组权限
   * @param permissions 权限列表
   * @returns 分组后的权限
   */
  static groupPermissionsByCategory(permissions: string[]): Record<string, string[]> {
    const grouped: Record<string, string[]> = {};
    
    permissions.forEach(permission => {
      const category = this.getPermissionCategory(permission);
      if (!grouped[category]) {
        grouped[category] = [];
      }
      grouped[category].push(permission);
    });
    
    return grouped;
  }

  /**
   * 权限检查高阶组件
   * @param permission 需要的权限
   * @param fallback 无权限时的回退组件
   * @returns 高阶组件
   */
  static withPermission(permission: string | string[], fallback?: React.ReactNode) {
    return function<P extends object>(Component: React.ComponentType<P>) {
      return function PermissionWrapper(props: P) {
        // 这里需要从Context获取权限检查函数
        // const { hasPermission, hasAnyPermission } = useAuth();
        
        // const hasAccess = Array.isArray(permission) 
        //   ? hasAnyPermission(permission)
        //   : hasPermission(permission);

        // return hasAccess ? <Component {...props} /> : (fallback || null);
        
        // 临时返回组件，实际使用时需要集成权限检查
        return <Component {...props} />;
      };
    };
  };
}

export default PermissionHelper;
